package com.kdg;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2017/8/28.
 * Streams类用处：http://blog.csdn.net/lvshaorong/article/details/51810288
 */
public class TestStream {

    public static void main(String[] args) {

        /**
         * java.util.Stream表示了某一种元素的序列，在这些元素上可以进行各种操作。
         * Stream操作可以是中间操作，也可以是完结操作。
         * 完结操作会返回一个某种类型的值，而中间操作会返回流对象本身，
         * 并且你可以通过多次调用同一个流操作方法来将操作结果串起来
         * （就像StringBuffer的append方法一样————译者注）。
         * Stream是在一个源的基础上创建出来的，
         * 如java.util.Collection中的list或者set（map不能作为Stream的源）。
         * Stream操作往往可以通过顺序或者并行两种方式来执行。
         */
        List<String> stringCollection = new ArrayList<>();
        stringCollection.add("ddd2");
        stringCollection.add("aaa2");
        stringCollection.add("bbb1");
        stringCollection.add("aaa1");
        stringCollection.add("bbb3");
        stringCollection.add("ccc");
        stringCollection.add("bbb2");
        stringCollection.add("ddd1");

        /**
         * Filter接受一个predicate接口类型的变量，并将所有流对象中的元素进行过滤。
         * 该操作是一个中间操作，因此它允许我们在返回结果的基础上再进行其他的流操作（forEach）。
         * ForEach接受一个function接口类型的变量，用来执行对每一个元素的操作。
         * ForEach是一个中止操作。它不返回流，所以我们不能再调用其他的流操作
         */
        stringCollection.stream().filter(s -> s.startsWith("a"))
                        .forEach(System.out::println);
//        Sorted是一个中间操作，能够返回一个排过序的流对象的视图。
//              流对象中的元素会默认按照自然顺序进行排序，除非你自己指定一个Comparator接口来改变排序规则。
//        但是sorted只是创建一个排序的流对象的视图，并不会改变原序列的顺序
        stringCollection.stream().sorted().filter(s -> s.startsWith("a"))
                        .forEach(System.out::println);
        /**
         * map是一个对于流对象的中间操作，通过给定的方法，
         * 它能够把流对象中的每一个元素对应到另外一个对象上。
         * 对于带泛型结果的流对象，具体的类型还要由传递给map的泛型方法来决定。
         */
        stringCollection.stream().map(String::toUpperCase).forEach(System.out::println);

        /**
         * 匹配操作有多种不同的类型，都是用来判断某一种规则是否与流对象相互吻合的。
         *  所有的匹配操作都是终结操作，只返回一个boolean类型的结果。
         */
        boolean anyStartsWithA =
                stringCollection
                        .stream()
                        .anyMatch((s) -> s.startsWith("a"));

        System.out.println(anyStartsWithA);      // true

        boolean allStartsWithA =
                stringCollection
                        .stream()
                        .allMatch((s) -> s.startsWith("a"));

        System.out.println(allStartsWithA);      // false
        /**
         * Count是一个终结操作，它的作用是返回一个数值，用来标识当前流对象中包含的元素数量。
         */
        long startsWithB =
                stringCollection
                        .stream()
                        .filter((s) -> s.startsWith("b"))
                        .count();

        System.out.println(startsWithB);    // 3
        long startsWithC =
                stringCollection
                        .stream()
                        .filter((s) -> s.startsWith("b"))
                        .count();

        System.out.println(startsWithC);    // 3

        /**
         * 并行流操作,并行操作则通过多线程执行。   --提升效率
         */
        stringCollection.parallelStream().sorted().forEach(System.out::println);

        /**
         * Map
         */
        Map<Integer, String> map = new HashMap<>();

        for(int i=0;i<10;i++){
            map.putIfAbsent(i,"vai"+i);  //putIfAbsent避免我们将null写入；
        }

        map.computeIfPresent(3, (num, val) -> val + num);
        System.out.println(map.get(3));          // vai33

        /*map.computeIfPresent(6, (num, val) -> null);
        System.out.println(map.containsKey(9)); */    // false

        map.computeIfAbsent(23, num -> "val" + num);
        map.containsKey(23);    // true

        map.computeIfAbsent(4, num -> "bam" + num);
        map.get(3);             // vai4

        map.remove(3,"vai3");  //还是会有vai33
        map.remove(3,"vai33");  //已移除

        System.out.println(map.getOrDefault(42, "not found"));  // not found

        map.forEach((key,value) -> {
            System.out.println(key);
            System.out.println(value);
        });

    }
}
